# 预定义每个数字（0-9）的"O型值"：数字中的闭合区域数量
# 例如：0有1个闭合区域，8有2个闭合区域
onum = [1, 0, 0, 0, 1, 0, 1, 0, 2, 1]  # 索引对应数字0-9


def get_o(x):
    """
    计算一个数字的O型值总和
    参数:
        x: 要计算的数字
    返回:
        O型值总和
    """
    res = 0
    while x > 0:
        digit = x % 10  # 获取最后一位数字
        res += onum[digit]  # 累加该数字的O型值
        x = x // 10  # 移除最后一位数字
    return res


def get_num(L, R, k):
    """
    统计区间[L, R]内O型值等于k的数字数量
    参数:
        L: 区间左边界
        R: 区间右边界
        k: 目标O型值
    返回:
        满足条件的数字数量
    """
    res = 0
    for i in range(L, R + 1):
        if get_o(i) == k:  # 检查当前数字的O型值
            res += 1
    return res


def main():
    """
    主函数，处理输入和分块逻辑
    """
    # 预处理阶段：统计所有6位数（000000-999999）的O型值分布
    cnt_s = [0] * 40  # 初始化统计数组，索引代表O型值，值代表出现次数

    # 遍历所有6位数（0-999999）
    for i in range(1000000):
        x = i
        cnt = 0
        # 计算当前6位数的O型值
        for _ in range(6):  # 固定处理6位数字
            digit = x % 10  # 获取最后一位
            cnt += onum[digit]  # 累加O型值
            x = x // 10  # 移除最后一位
        cnt_s[cnt] += 1  # 统计该O型值出现的次数

    # 读取输入：区间[L, R]和目标O型值k
    L, R, k = map(int, input().split())

    ST = 1000000  # 定义分块大小（1,000,000）

    # 判断区间长度是否小于等于分块大小
    if R - L <= ST:
        # 小范围直接暴力计算
        print(get_num(L, R, k))
    else:
        # 大范围采用分块处理
        res = 0  # 初始化结果计数器

        # 处理左边界不完整块（从L到下一个完整块的起始）
        left_end = (L // ST + 1) * ST-1  # -1 是因为右端点是到999999
        res += get_num(L, left_end, k)

        # 处理右边界不完整块（从最后一个完整块开始到R）
        right_start = (R // ST) * ST
        res += get_num(right_start, R, k)

        # 处理中间的完整块
        a = L // ST + 1  # 第一个完整块的索引
        b = R // ST  # 最后一个完整块的索引
        for i in range(a, b):  # i为块的编号
            # 计算当前块编号的O型值
            x = get_o(i)
            # 如果块编号的O型值小于等于k,才需要查表,大于这直接跳过,因为当前块号的O型值都已经大于给定的数了，它区间里面的O型值就更大的
            if x <= k:
                # 使用预处理结果快速统计
                res += cnt_s[k - x]  # k-x，减去块号的O型值计算剩下需要的O型值

        # 输出最终结果
        print(res)


if __name__ == "__main__":
    main()